﻿using System.Collections.Generic;
using XLua;
#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;

    public class UnityEngineTransformWrap
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(UnityEngine.Transform);
            Utils.BeginObjectRegister(type, L, translator, 0, 21, 19, 13);

            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParent", _m_SetParent);
            Utils.RegisterFunc(
                L,
                Utils.METHOD_IDX,
                "SetPositionAndRotation",
                _m_SetPositionAndRotation
            );
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Translate", _m_Translate);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rotate", _m_Rotate);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RotateAround", _m_RotateAround);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "LookAt", _m_LookAt);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformDirection", _m_TransformDirection);
            Utils.RegisterFunc(
                L,
                Utils.METHOD_IDX,
                "InverseTransformDirection",
                _m_InverseTransformDirection
            );
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformVector", _m_TransformVector);
            Utils.RegisterFunc(
                L,
                Utils.METHOD_IDX,
                "InverseTransformVector",
                _m_InverseTransformVector
            );
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformPoint", _m_TransformPoint);
            Utils.RegisterFunc(
                L,
                Utils.METHOD_IDX,
                "InverseTransformPoint",
                _m_InverseTransformPoint
            );
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "DetachChildren", _m_DetachChildren);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAsFirstSibling", _m_SetAsFirstSibling);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAsLastSibling", _m_SetAsLastSibling);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSiblingIndex", _m_SetSiblingIndex);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSiblingIndex", _m_GetSiblingIndex);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsChildOf", _m_IsChildOf);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetChild", _m_GetChild);

            Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "localPosition", _g_get_localPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "eulerAngles", _g_get_eulerAngles);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "localEulerAngles", _g_get_localEulerAngles);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "right", _g_get_right);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "up", _g_get_up);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "forward", _g_get_forward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "localRotation", _g_get_localRotation);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "localScale", _g_get_localScale);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "parent", _g_get_parent);
            Utils.RegisterFunc(
                L,
                Utils.GETTER_IDX,
                "worldToLocalMatrix",
                _g_get_worldToLocalMatrix
            );
            Utils.RegisterFunc(
                L,
                Utils.GETTER_IDX,
                "localToWorldMatrix",
                _g_get_localToWorldMatrix
            );
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "root", _g_get_root);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "childCount", _g_get_childCount);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lossyScale", _g_get_lossyScale);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasChanged", _g_get_hasChanged);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hierarchyCapacity", _g_get_hierarchyCapacity);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hierarchyCount", _g_get_hierarchyCount);

            Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "localPosition", _s_set_localPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "eulerAngles", _s_set_eulerAngles);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "localEulerAngles", _s_set_localEulerAngles);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "right", _s_set_right);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "up", _s_set_up);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "forward", _s_set_forward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation", _s_set_rotation);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "localRotation", _s_set_localRotation);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "localScale", _s_set_localScale);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "parent", _s_set_parent);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasChanged", _s_set_hasChanged);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hierarchyCapacity", _s_set_hierarchyCapacity);

            Utils.EndObjectRegister(type, L, translator, null, null, null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);

            Utils.EndClassRegister(type, L, translator);
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            return LuaAPI.luaL_error(L, "UnityEngine.Transform does not have a constructor!");
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetParent(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Transform>(L, 2))
                {
                    UnityEngine.Transform _p = (UnityEngine.Transform)
                        translator.GetObject(L, 2, typeof(UnityEngine.Transform));

                    gen_to_be_invoked.SetParent(_p);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Transform>(L, 2)
                    && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)
                )
                {
                    UnityEngine.Transform _parent = (UnityEngine.Transform)
                        translator.GetObject(L, 2, typeof(UnityEngine.Transform));
                    bool _worldPositionStays = LuaAPI.lua_toboolean(L, 3);

                    gen_to_be_invoked.SetParent(_parent, _worldPositionStays);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.SetParent!");
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPositionAndRotation(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    UnityEngine.Vector3 _position;
                    translator.Get(L, 2, out _position);
                    UnityEngine.Quaternion _rotation;
                    translator.Get(L, 3, out _rotation);

                    gen_to_be_invoked.SetPositionAndRotation(_position, _rotation);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Translate(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    gen_to_be_invoked.Translate(_x, _y, _z);

                    return 0;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _translation;
                    translator.Get(L, 2, out _translation);

                    gen_to_be_invoked.Translate(_translation);

                    return 0;
                }
                if (
                    gen_param_count == 5
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                    && translator.Assignable<UnityEngine.Space>(L, 5)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);
                    UnityEngine.Space _relativeTo;
                    translator.Get(L, 5, out _relativeTo);

                    gen_to_be_invoked.Translate(_x, _y, _z, _relativeTo);

                    return 0;
                }
                if (
                    gen_param_count == 5
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                    && translator.Assignable<UnityEngine.Transform>(L, 5)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);
                    UnityEngine.Transform _relativeTo = (UnityEngine.Transform)
                        translator.GetObject(L, 5, typeof(UnityEngine.Transform));

                    gen_to_be_invoked.Translate(_x, _y, _z, _relativeTo);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Vector3>(L, 2)
                    && translator.Assignable<UnityEngine.Space>(L, 3)
                )
                {
                    UnityEngine.Vector3 _translation;
                    translator.Get(L, 2, out _translation);
                    UnityEngine.Space _relativeTo;
                    translator.Get(L, 3, out _relativeTo);

                    gen_to_be_invoked.Translate(_translation, _relativeTo);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Vector3>(L, 2)
                    && translator.Assignable<UnityEngine.Transform>(L, 3)
                )
                {
                    UnityEngine.Vector3 _translation;
                    translator.Get(L, 2, out _translation);
                    UnityEngine.Transform _relativeTo = (UnityEngine.Transform)
                        translator.GetObject(L, 3, typeof(UnityEngine.Transform));

                    gen_to_be_invoked.Translate(_translation, _relativeTo);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.Translate!");
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Rotate(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _xAngle = (float)LuaAPI.lua_tonumber(L, 2);
                    float _yAngle = (float)LuaAPI.lua_tonumber(L, 3);
                    float _zAngle = (float)LuaAPI.lua_tonumber(L, 4);

                    gen_to_be_invoked.Rotate(_xAngle, _yAngle, _zAngle);

                    return 0;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _eulers;
                    translator.Get(L, 2, out _eulers);

                    gen_to_be_invoked.Rotate(_eulers);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Vector3>(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                )
                {
                    UnityEngine.Vector3 _axis;
                    translator.Get(L, 2, out _axis);
                    float _angle = (float)LuaAPI.lua_tonumber(L, 3);

                    gen_to_be_invoked.Rotate(_axis, _angle);

                    return 0;
                }
                if (
                    gen_param_count == 5
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                    && translator.Assignable<UnityEngine.Space>(L, 5)
                )
                {
                    float _xAngle = (float)LuaAPI.lua_tonumber(L, 2);
                    float _yAngle = (float)LuaAPI.lua_tonumber(L, 3);
                    float _zAngle = (float)LuaAPI.lua_tonumber(L, 4);
                    UnityEngine.Space _relativeTo;
                    translator.Get(L, 5, out _relativeTo);

                    gen_to_be_invoked.Rotate(_xAngle, _yAngle, _zAngle, _relativeTo);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Vector3>(L, 2)
                    && translator.Assignable<UnityEngine.Space>(L, 3)
                )
                {
                    UnityEngine.Vector3 _eulers;
                    translator.Get(L, 2, out _eulers);
                    UnityEngine.Space _relativeTo;
                    translator.Get(L, 3, out _relativeTo);

                    gen_to_be_invoked.Rotate(_eulers, _relativeTo);

                    return 0;
                }
                if (
                    gen_param_count == 4
                    && translator.Assignable<UnityEngine.Vector3>(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && translator.Assignable<UnityEngine.Space>(L, 4)
                )
                {
                    UnityEngine.Vector3 _axis;
                    translator.Get(L, 2, out _axis);
                    float _angle = (float)LuaAPI.lua_tonumber(L, 3);
                    UnityEngine.Space _relativeTo;
                    translator.Get(L, 4, out _relativeTo);

                    gen_to_be_invoked.Rotate(_axis, _angle, _relativeTo);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.Rotate!");
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RotateAround(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    UnityEngine.Vector3 _point;
                    translator.Get(L, 2, out _point);
                    UnityEngine.Vector3 _axis;
                    translator.Get(L, 3, out _axis);
                    float _angle = (float)LuaAPI.lua_tonumber(L, 4);

                    gen_to_be_invoked.RotateAround(_point, _axis, _angle);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LookAt(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Transform>(L, 2))
                {
                    UnityEngine.Transform _target = (UnityEngine.Transform)
                        translator.GetObject(L, 2, typeof(UnityEngine.Transform));

                    gen_to_be_invoked.LookAt(_target);

                    return 0;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _worldPosition;
                    translator.Get(L, 2, out _worldPosition);

                    gen_to_be_invoked.LookAt(_worldPosition);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Transform>(L, 2)
                    && translator.Assignable<UnityEngine.Vector3>(L, 3)
                )
                {
                    UnityEngine.Transform _target = (UnityEngine.Transform)
                        translator.GetObject(L, 2, typeof(UnityEngine.Transform));
                    UnityEngine.Vector3 _worldUp;
                    translator.Get(L, 3, out _worldUp);

                    gen_to_be_invoked.LookAt(_target, _worldUp);

                    return 0;
                }
                if (
                    gen_param_count == 3
                    && translator.Assignable<UnityEngine.Vector3>(L, 2)
                    && translator.Assignable<UnityEngine.Vector3>(L, 3)
                )
                {
                    UnityEngine.Vector3 _worldPosition;
                    translator.Get(L, 2, out _worldPosition);
                    UnityEngine.Vector3 _worldUp;
                    translator.Get(L, 3, out _worldUp);

                    gen_to_be_invoked.LookAt(_worldPosition, _worldUp);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.LookAt!");
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TransformDirection(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    var gen_ret = gen_to_be_invoked.TransformDirection(_x, _y, _z);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _direction;
                    translator.Get(L, 2, out _direction);

                    var gen_ret = gen_to_be_invoked.TransformDirection(_direction);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(
                L,
                "invalid arguments to UnityEngine.Transform.TransformDirection!"
            );
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InverseTransformDirection(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    var gen_ret = gen_to_be_invoked.InverseTransformDirection(_x, _y, _z);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _direction;
                    translator.Get(L, 2, out _direction);

                    var gen_ret = gen_to_be_invoked.InverseTransformDirection(_direction);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(
                L,
                "invalid arguments to UnityEngine.Transform.InverseTransformDirection!"
            );
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TransformVector(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    var gen_ret = gen_to_be_invoked.TransformVector(_x, _y, _z);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _vector;
                    translator.Get(L, 2, out _vector);

                    var gen_ret = gen_to_be_invoked.TransformVector(_vector);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(
                L,
                "invalid arguments to UnityEngine.Transform.TransformVector!"
            );
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InverseTransformVector(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    var gen_ret = gen_to_be_invoked.InverseTransformVector(_x, _y, _z);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _vector;
                    translator.Get(L, 2, out _vector);

                    var gen_ret = gen_to_be_invoked.InverseTransformVector(_vector);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(
                L,
                "invalid arguments to UnityEngine.Transform.InverseTransformVector!"
            );
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TransformPoint(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    var gen_ret = gen_to_be_invoked.TransformPoint(_x, _y, _z);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _position;
                    translator.Get(L, 2, out _position);

                    var gen_ret = gen_to_be_invoked.TransformPoint(_position);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(
                L,
                "invalid arguments to UnityEngine.Transform.TransformPoint!"
            );
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InverseTransformPoint(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                int gen_param_count = LuaAPI.lua_gettop(L);

                if (
                    gen_param_count == 4
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)
                    && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)
                )
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);

                    var gen_ret = gen_to_be_invoked.InverseTransformPoint(_x, _y, _z);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
                if (gen_param_count == 2 && translator.Assignable<UnityEngine.Vector3>(L, 2))
                {
                    UnityEngine.Vector3 _position;
                    translator.Get(L, 2, out _position);

                    var gen_ret = gen_to_be_invoked.InverseTransformPoint(_position);
                    translator.PushUnityEngineVector3(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

            return LuaAPI.luaL_error(
                L,
                "invalid arguments to UnityEngine.Transform.InverseTransformPoint!"
            );
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DetachChildren(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    gen_to_be_invoked.DetachChildren();

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetAsFirstSibling(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    gen_to_be_invoked.SetAsFirstSibling();

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetAsLastSibling(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    gen_to_be_invoked.SetAsLastSibling();

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetSiblingIndex(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);

                    gen_to_be_invoked.SetSiblingIndex(_index);

                    return 0;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSiblingIndex(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    var gen_ret = gen_to_be_invoked.GetSiblingIndex();
                    LuaAPI.xlua_pushinteger(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Find(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    string _n = LuaAPI.lua_tostring(L, 2);

                    var gen_ret = gen_to_be_invoked.Find(_n);
                    translator.Push(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsChildOf(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    UnityEngine.Transform _parent = (UnityEngine.Transform)
                        translator.GetObject(L, 2, typeof(UnityEngine.Transform));

                    var gen_ret = gen_to_be_invoked.IsChildOf(_parent);
                    LuaAPI.lua_pushboolean(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetEnumerator(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    var gen_ret = gen_to_be_invoked.GetEnumerator();
                    translator.PushAny(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetChild(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);

                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);

                    var gen_ret = gen_to_be_invoked.GetChild(_index);
                    translator.Push(L, gen_ret);

                    return 1;
                }
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_position(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.position);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_localPosition(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.localPosition);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_eulerAngles(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.eulerAngles);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_localEulerAngles(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.localEulerAngles);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_right(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.right);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_up(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.up);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_forward(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.forward);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rotation(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.rotation);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_localRotation(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.localRotation);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_localScale(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.localScale);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_parent(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.parent);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_worldToLocalMatrix(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.worldToLocalMatrix);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_localToWorldMatrix(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.localToWorldMatrix);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_root(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.root);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_childCount(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.childCount);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lossyScale(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.lossyScale);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasChanged(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasChanged);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hierarchyCapacity(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.hierarchyCapacity);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hierarchyCount(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.hierarchyCount);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_position(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.position = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_localPosition(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.localPosition = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_eulerAngles(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.eulerAngles = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_localEulerAngles(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.localEulerAngles = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_right(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.right = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_up(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.up = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_forward(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.forward = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rotation(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Quaternion gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.rotation = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_localRotation(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Quaternion gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.localRotation = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_localScale(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;
                translator.Get(L, 2, out gen_value);
                gen_to_be_invoked.localScale = gen_value;
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_parent(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.parent = (UnityEngine.Transform)
                    translator.GetObject(L, 2, typeof(UnityEngine.Transform));
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasChanged(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasChanged = LuaAPI.lua_toboolean(L, 2);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hierarchyCapacity(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)
                    translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hierarchyCapacity = LuaAPI.xlua_tointeger(L, 2);
            }
            catch (System.Exception gen_e)
            {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
    }
}
